# Implementation of Singularity Functions to solve Beam Bending problems

## Basic Information

University: Indian Institute of Technology, Kharagpur
Major: Mathematics and Computing
Timezone: IST (UTC +5:30)

## Personal Background

My name is Sampad Kumar Saha, a second year undergraduate student at IIT Kharagpur, India. I am pursuing a degree in Mathematics and Computing. I was very much interested in learning Mathematics since my high schools. After joining the university, I got exposed towards the field of Computer Science. I have taken courses like Probability and Statistics, Discrete Mathematics, Advanced Engineering Mathematics, Numerical Methods, Mechanics of Materials, Programming and Data Stuctures and Design and Analysis of algorithm.

# Programming Details

## Platform

I am using Ubuntu 14.04 LTS as an operating system and Sublime Text as my primary text editor with some cool plugins such as DocBlockr, Emmet which really help me to write programs faster. Its multi-edit feature really assit me to search or edit anything quite easily. I am quite familiar with the concept of version control system and have been using Git and GitHub since quite some time and have enough knowledge to carry out the project successfully.

## Experience

I started learning programming about two years ago with the C language. Then I got introduced to Web Development and have developed some basic web applications.

For nearly one year I have started learning object oriented programming and then I got to know about python for being the most widely used high-level, general-purpose scripting language. Its dynamic type system and its pretty cool syntax allows me to express concepts in fewer lines of code.

## Contribution to Sympy

I was introduced to Sympy by Abinash Meher. I have started contributing to Sympy by fixing easy-to-fix bugs since then have been learning a lot from this great community. Sympy has smooth transition between symbolic and numeric world. Sympy objects can be easily used to create symbolic mathematical expressions to compute limits, integrals, derivatives and to solve equations very efficiently. Its large number of modules provides succor to tackle almost every mathematical problems.

Here is the link to all my contributions to Sympy.

• (Merged) `Replaced 'repr' with 'srepr' in the tutorial` #10225 This patch provides a clarification about srepr in the docs.

• (Merged) `Modified the srepr docstring` #10253.

• (Unmerged) `[WIP] Adding the condition for changing the latex color dynamically by init_printing() .` #10729 I am trying to add a condition in order to change the latex color dynamically with the background color of console.

• (Merged) `Added test for Interval(..) in Interval(..)` #10741.

• (Merged) `Fixed a typo` #10862.

• (Unmerged) `Rename the simplify method of DiracDelta class` #10863. The patch would rename the simplify method of DiracDelta class since, it doesn't match the API of the usual simplify function.

# The Project

## Overview

Sympy is a pure python library which provides a full featured computer algebra system in a very comprehensible and easily extensible way. As mentioned in the idea page, Sympy currently lacks a stand-alone Singularity Function module.

We can use `Piecewise` for denoting a Singularity Function but it would be very complicated for the users to handle and perform complex operations using those functions.

For example :

• Using `Piecewise` :-
```In [0] : 3*Piecewise(((x-5)**3,x>=5),(0,x<5)) + 4*Piecewise(('undefined', Eq(x, 4)),(0,True)) - 5*Piecewise(('undefined', Eq(x, -2)),(0,True))
Out[0] :

⎛⎧       3            ⎞     ⎛⎧                     ⎞     ⎛⎧                      ⎞
⎜⎪(x - 5)    for x ≥ 5⎟     ⎜⎪ undefined for x = 4 ⎟     ⎜⎪undefined  for x = -2 ⎟
3⋅⎜⎨                    ⎟ + 4⋅⎜⎨                     ⎟ - 5⋅⎜⎨                      ⎟
⎜⎪    0      for x < 5⎟     ⎜⎪    0      otherwise ⎟     ⎜⎪    0      otherwise  ⎟
⎝⎩                    ⎠     ⎝⎩                     ⎠     ⎝⎩                      ⎠```

• Using `SingularityFunction` (Class to be implement in Singularity Function module) :-
```In [1] : 3*SingularityFunction(x, 5, 3)  + 4*SingularityFunction(x, 4, -1) - 5*SingularityFunction(x, -2, -2)
Out[1] :
3            -1           -2
3⋅<x - 5>  + 4⋅<x - 4>  - 5⋅<x + 2> ```

`SingularityFunction` would be more handy and simpler to use than `Piecewise`. We cannot represent doublet function or any singularity function having negetive exponents using `Piecewise`.

My proposal aims to add a module to Sympy to represent a Singularity Function and implement different mathematical operations for solving different beam bending problems using the module, along with a documentation citing examples of using this module for solving beam bending problems.

## Motivation

Singularity Functions are one of the most important functions which are used in many aspects of science. We use these functions to :

• Solve beam bending problems in mechanics.
For example:
- A Point load can be represented as DiracDelta function.
- A Moment can be represented as Doublet function.

• Circuital analysis in electronic models.
For example:
- A Unit Step function can be used to denote the current during the on and off position of the switch in a circuit.
- To find the step response and natural response of RC and RL curcuits.

• Synthesizing different waveforms in communication engineering.
For example:
- A rectangular pulse signal can be denoted as the combination of two step functions.
- A saw-tooth waveform is generated by shifting a ramp function and then reflect it since this waveform is used in a cathode-ray oscilloscope as the timing signal.
- The impulse function is significant because it depicts the nature of the system. The poles of impulse response are the poles of the system.

But in all these engineering aspects the use of manual calculations is advocated which is very error prone. Sometimes people use small simple functions and many assumptions to promote manual calculations with ease but by this way the problems becomes an over-simplified models which cannot adequately portray physical systems.

The best way to tackle this issue would be by implementing a full fledged computer algebra system supporting all the mathematical functionality on Singularity Functions. In this way, productivity would get significantly increased for solving problems that are more realistic and challenging, by giving more focus to the physical concepts rathen than delegating with the horrendous mathematics involved.

## Theory

Singularity functions are a class of discontinuous functions that contain singularities, i.e. they are discontinuous at their singular points.

Adopting MacAuley’s angle-brackets notation, we can represent a Singularity Function as:

• For `n ≥ 0` :
``````                    ⎧       n
n     ⎪(x - a)    for x ≥ a
f(x) = <x - a>   =  ⎨
⎪   0       for x < a
⎩
``````
• For `n < 0`:
``````       n
<x - a>   is not a conventional function.
It is a distribution or a limit of a sequence of functions.
``````

These functions exhibit strong singular behavior at `x = a`.

For `n < 0` the integer `n` is not an exponent in the usual sense but an index which depicts the singularity strength. It actually characterizes the kind of discontinuity. Otherwise, for non-negetive integers it can be interpreted as an exponent.

The following are the most widely used Singularity Functions

• Doublet Function
``````            -2
<x - a>    ≡ Derivative of Dirac Delta Function
``````
• DiracDelta Function
``````            -1
<x - a>    ≡ Derivative of Step Function
``````
• Heaviside Function (Step Function)
``````
0      ⎧1  for x ≥ a
<x - a>  =    ⎨
⎩0  for x < a
``````
• Ramp Function
``````
1      ⎧x - a   for x ≥ a
<x - a>   =   ⎨
⎩  0     for x < a
``````
• Parabolic Ramp Function
``````                   ⎧       2
2      ⎪(x - a)    for x ≥ a
<x - a>   =   ⎨
⎪   0       for x < a
⎩
``````
• n-th Order Ramp Function (For `n>=0`)
``````                   ⎧       n
n      ⎪(x - a)    for x ≥ a
<x - a>   =   ⎨
⎪   0       for x < a
⎩
``````

The Singularity Functions acts as a Mathematical Switch. For `x >= a` the Switch turns ON i.e. `1` and for `x < a` the Switch turns OFF i.e. `0` .

### Integration

Integration of the Singularity Functions for `n ≥ 0` follows the same rule as for the Ordinary Functions but for `n ≤ 0` it follows the rules of the Operational Calculus.

``````x                 ⎧       n + 1
⌠                 ⎪<x - a>          for n ≤ 0
⎮        n        ⎪
⎮ <x - a>   dx =  ⎨       n + 1
⌡                 ⎪<x - a>
-∞                ⎪─────────────    for n ≥ 0
⎩    n + 1
``````

### Differentiation

Differentiation of Singularity Functions for `n > 0` follows the same rule as for Ordinary Function. For `n = 0, -1` the power as a coefficient is not multiplied else rest are same.

``````                 ⎧             n-1
d  ⎛       n⎞    ⎪  n ⋅ <x - a>              For n > 0
── ⎜<x - a> ⎟  = ⎨
dx ⎝        ⎠    ⎪           n-1
⎩    <x - a>                For n = 0, -1
``````

## The Plan and Prototype

I have planned to divide my work into four phases. I have planned to undergo Test Driven Development where I will be implementing code by writing its tests first, seeing them fail, then writing the code to make the tests pass. This way there will be a perfect match for the ideals and principles of the Agile Development process. After completion of each phase we will have code that can be merged with the codebase, after the tests pass, and used right away. :-

### Phase 1 : Improving the existing Discontinuity Functions

There are two existing discontinuity functions in Sympy viz. `Heaviside` and `DiracDelta`. I would try to improve them .

• Issue :- There is as issue in `DiracDelta`. While doing integral of this `integrate(f(x)*DiracDelta(x-a, n), (x, -oo, oo))` it just prints the same whereas following the properties of DiracDelta function it should output `(-1)**n * diff(f(x),x , n).subs(x,a)`.
```In  [4] : integrate(f(x)*DiracDelta(x-a, n), (x, -oo, oo))
Out [4] :
∞
⌠
⎮  f(x)⋅DiracDelta(-a + x, n) dx                 #Got
⌡
-∞
Out [4] : (-1)**n*diff(f(x), x, n).subs(x,a)     #Expected```

I have planned to start my project by rectifying this issue first.

• Piecewise representation : I would implement a method `_eval_rewrite_as_Piecewise` for DiracDelta to represent it in a piecewise order. I expect the output API as :-
```In  [] : x = Symbol('x', real=True)

In  [] : f = DiracDelta(x - 5)

In  [] : f.rewrite(Piecewise)
Out [] :

⎧ undefined       for x = 5
⎨
⎩    0            otherwise ```
• Rename simplify :- There have been issues like #7716 and #8798, which are being raised because of the simplify method in instance of `DiracDelta`. It needed to be renamed since it doesn't match the API of the usual simplify function existing in Sympy. I have opened a pull request #10863 which would rectify the issues. I will avoid the API breakage and would try to deprecate the old API, if possible. I will discuss about the API change with the community. I will abide by the rules of Deprecating policy of Sympy.

### Phase 2 : Implementation of SingularityFunction

I would create a class `SingularityFunction` which would inherit `Function` and import both `DiracDelta` and `Heaviside` internally in order to represent any singularity functions. It would take a variable `x`, an offset `a`, a power `n` as arguments.

I have planned to add a function in the existing printing module in Sympy to print the Singularity Functions. I will be overloading the `__repr__` and the `__str__` operator. It would be printing as :-

```In  []  : SingularityFunction(x ,5, 3)
Out [] :
3
<x - 5>```

We have a previously built `DiracDelta` and `Heaviside`. I will be using both of them to represent a SingularityFunction. A psuedocode is as follows:

```SingularityFunction(x, a, n):
if(n = -2):
# Doublet Function, derivative of DiracDelta Function
return diff(DiracDelta(x - a))
if(n = -1):
# DiracDelta Function
return DiracDelta(x - a)
if(n >= 0):
return (x - a)**n*Heaviside(x - a)```

Now any Singularity Functions can be generated and printed successfully. I will implement some functionalities on singularity functions by defining some new methods :-

• Addition and Substraction : I will be overloading `__add__` operator to implement the addition of singularity functions. The substraction part is pretty straight-forward.We just need to do `f - g = f + -1*g` . This will just output the addition and substraction as :-
```In  [] : SingularityFunction(x, 5, -1) + SingularityFunction(x, -6, 0)
Out [] :
-1          0
<x - 5>  + <x + 6>

In  [] : SingularityFunction(x, 5, -1) - SingularityFunction(x, -6, 0)
Out [] :
-1         0
<x - 5>  - <x + 6>```
• Differentiation : Differentiation of a singularity function is quite easy and direct. The exponents would be reduced by 1 and would be multiplied with the expression before being reduced for `n > 0` while for `n == 0 or n == -1` only the exponent will get reduced by 1. It would follow the structure of `Derivative` that is there in Sympy. We can have unevaluated derivative instances using `evaluate = False` as an argument. I will be adding an instance method `fdiff()` for the purpose of first differentiation. A pseudocode for implementing the differentiation functionality is as :
``` def fdiff(n):
if n == 0 or n == -1 :
return SingularityFunction(x, a, n-1)
if n > 0 :
return n*SingularityFunction(x, a, n-1)
else
Error message ```

The Output API would be :-

```In  []  : f = SingularityFunction(x, 2, 0) + SingularityFunction(x, -5, -1) - SingularityFunction(x, 1, 3)
Out []  :
1          0           3
<x - 2>  + <x + 5>   + <x - 1>

In  []  :f.diff(evaluate = False)
Out []  :

d  ⎛       1          0           3 ⎞
── ⎝<x - 2>  + <x + 5>   + <x - 1>  ⎠
dx

In  []  : f.diff()
Out []  :
0           -1            2
<x - 2>   + <x + 5>   - 3⋅<x - 1>

In  []  : f.diff(x,2)
Out []  :
-1          -2            1
<x - 2>   + <x + 5>   - 6⋅<x - 1>    ```
• Integration : I have discussed in theory that integration of singularity functions follows different approach for different values of the exponent. I will follow the structure of integration that is there in Sympy. It will be quite easy and straightforword. I will use `Integral` to output an unevaluated instance and both `Integral.doit()` and `integrate()` can be used to output an integrated or evaluated instance. The Output would somehow be like polynomial integration for exponent greater than 0 and for exponent being negative, only the exponent would increase by 1.

The Output API will be :-

```In  []  : f = SingularityFunction(x, 4, -2) + SingularityFunction(x, 6, -1) - SingularityFunction(x, -7, 3)
Out []  :
-2          -1          3
<x - 4>   + <x - 6>   + <x + 7>

In  []  :Integral(f)
Out []  :
⌠
⎮        -2          -1          3
⎮ <x - 4>   + <x - 6>   + <x + 7>  dx
⌡

In  []  :Integral(f).doit()
Out []  :
-1          0                4
<x - 4>   + <x - 6>   - 0.25⋅<x + 7>

In  []  : f.integrate()
Out []  :
-1          0                4
<x - 4>   + <x - 6>   - 0.25⋅<x + 7>```
• Continous Piecewise : I will create a method `_eval_rewrite_as_Piecewise`. This method would convert a singularity function into its piecewise form. We can use it to get the piecewise output of a function after we perform any mathematical operations on that singularity function. It will output the singularity function into different pieces depending upon the intervals of the variable. The user can get the clear visualization of different functions which all is combined to form that singularity function expression.

A desired API would be :-

```In  [] : x = Symbol('x', real=True)

In  [] : f = SingularityFunction(x, 9, 3) + SingularityFunction(x, -2, 1)
Out [] :
3          1
<x - 9>  + <x + 2>

In  [] : f.diff().rewrite(Piecewise)
Out [] :

⎧       0              for x < -2
⎪
⎪              2
⎨     3⋅(x - 9)        for x < 9 ∧ x ≥ -2
⎪
⎪          2
⎩  3⋅(x - 9)  + 1      for x ≥ 9

In  [] : f.integrate().rewrite(Piecewise)
Out [] :

⎧            0                   for x < -2
⎪
⎪                 2
⎨      0.5⋅(x + 2)               for x < 9 ∧ x ≥ -2
⎪
⎪             4              2
⎩ 0.25⋅(x - 9)  + 0.5⋅(x + 2)    for x ≥ 9
```

### Phase 3 : Implementation of Beam Module using the Singularity Function Module.

By the time I reach this phase of my project, I'll already have implemented a module for singularity functions in a purely mathematical way.

Solving Beam Bending Problems using Singularity Functions is one of the important aspects of this project.
I would like to create an another module `beam_bending` which would be dealing with the beam bending problems only. This module would internally import and utilize the Singularity Function module. I would be implementing the following classes under the Beam Bending Module.

• `Beam` : This class would be used to create a Beam object by taking `l` length, `E` Young's Modulus, `I` Moment of Inertia as inputs. Some of its attributes and methods are :

``````- `Length`, `Young's Modulus`, `Moment of Inertia`  : The length, Young's Modulus, Moment of Inertia of the a beam object would be stored respectively. By default, these attribute will hold values `l`, `E`, `I` respectively.

- `Apply()`  : This method would be applying the loads, passed as an argument, on the beam objects. It will be using `*args` to take variable number of loads as input . This would store all the applied loads in the form of Singularity Functions by creating a beam object attribute dynamically. The attribute would contain each and every load applied on the beam. If at any location the load is represented as a Moment, it will be stored as a doublet function.

- `BoundaryConditions()` : This method would take up the initial conditions or the boundary conditions for adding constants of integration while integrating any function and to solve for them. It would take inputs in the form of python dictionary as arguments mentioning the slope or deflection of a beam at a particular location. By default this attribute would have the values _`{v(0) !=  0 , v.diff(0) = 0 }`_  something equivalent to this.
``````

The input format would be like : `BoundaryConditions({v(0) : 0, v.diff(0) : 1})`.

``````  - `LoadDistribution()` : Using the stored load functions produced by `apply()` method, this method would combine and simplify all those load functions into a single expression and will output it as the load distribution function in the form of Singularity Functions.

- `ShearForce()` : Integrating the `LoadDistribution()` , this method would output the shear force function in the form of Singularity Functions.

- `BendingMoment()` : Evaluating `-1*ShearForce().integrate()`, this method would output the bending moment function in the form of Singularity Functions.

- `Slope()` : This method would check the Boundary Condition object attribute. Depending on the values of that attribute this method would evaluate `1/(E*I)*BendingMoment().integrate()` and add the constant of integration. Further it would solve for that constant if possible  else it would output the slope function in the form of Singularity Functions keeping the constant in that expression.

- `Deflection()` : Implementation of this method is almost similar to `Slope()`. Depending on the values of the attribute that stores the boundary condition this method would integrate the `Slope()` and add the constant of integration. This method would output the deflection curve in the form of Singularity Functions along with the value of the constant, if possible, else output expression would have the constants in it.
``````
• `DistributedLoad` : This class would be used to create a distributed load object by taking the starting and ending point along with the value of that applied load as inputs as tuples. The values can take any function. It can be polynimial, exponential, trignometric etc. Attributes of this class will be : - `Start` : Denoting the starting point of the applied load. - `End` : Denoting the ending point of the applied load. - `Value` : Denoting the value of the applied load.

• `Point Load` : This class would be used to create a point load object by taking the exact location and the value of that applied load as inputs. Using it a moment can also be represented in the load function. Use `Doublet` as a point load at the loaction of the applied moment. Attributes of this class will be : - `location` : Denoting the exact point on the beam object of the applied load.
- `Value` : Denoting the value of the applied load.

The API would look like:-

```In  [] : from sympy import Beam, DistributedLoad, PointLoad

In  [] : b = Beam(length = 4, E, I)

In  [] : Load1 = DistrubutedLoad(start = 2, end = 4, value = 6)

In  [] : Load2 = PointLoad((location = 0, value = -3),(location = -9, value = 4))

In  [] : b.BoundaryCondition({v(4) : 0})

Out [] :
-1            0             -1
-3⋅<x - 0>   + 6⋅<x - 2>   - 9⋅<x - 4>

In  [] : b.shearForce          # Outputs the Shear Force  Function
Out [] :
0             1             0
-3⋅<x - 0>   + 6⋅<x - 2>   - 9⋅<x - 4>

In  [] : b.bendingMoment       # Outputs the bending Moment Function
Out [] :
1             2             1
3⋅<x - 0>   - 3⋅<x - 2>   + 9⋅<x - 4>

In  [] : b.slope               # Outputs the Slope Function
Out [] :
1              2          3              2
─── (1.5⋅<x - 0>  - <x - 2>  + 4.5⋅<x - 4>  - 7)
E⋅I

In  [] : b.deflection          # Outputs the deflection Function
Out [] :
1              3               4              3
─── (0.5⋅<x - 0>  - 0.25⋅<x - 2>  + 1.5⋅<x - 4>  - 7⋅x)
E⋅I   ```

### Phase 4 : Documenting tutorials and examples

This phase would be the epilouge of my project. By the time I reach this phase, I would have successfully implemented a Singularity Funtion module and a Beam Bending Module along with the tests and docs.

Here, I would focus on preparing a documentation of examples and tutorials to depict how to use the beam module to solve a beam bending problem all alone. This documentation would describe each feature of the module, and assists the user in realizing these features along with many examples of beam bending problems solved using this implemented API. It would be very important as well as useful for the users if they have many examples solved in the docs. Since,the tutorial approach is considered the most useful for a new user, in which they are guided through almost each and every functionality for accomplishing particular tasks, I would provide plenty of examples on solving the beam problems along with describing every functionality. It is a quite true that people tend to use a software more if the documentations are top notch.

NOTE : Each phase will start with a major pull request, I will be committing in that pull request for each functionalities that will get implemented. At the end of each phase, there will be a independently standalone pull requests with all the docs and tests required for every functionalities. This pull request can be directly merged into the codebase.

# Timeline (Tentative)

Any Plans/Commitment (During GSoC):-

• I am having End Semester Examination from 21 April to 29 April. But this would not be an issue for having Community Bonding. My summer vacations start by 30 April. I would be able to devote 40 - 50 hours a week during the project, since I have no other big commitments other than GSoC.

• I might not be able to code for the full time form 25 May - 29 May (max 4 days) as I have to go for a family vacation. I will be compensating the work during the commmunity bonding period as well as in the other weeks, since I will be free for the whole summer break. I can give a strong assurance that this vacation will not affect the progress of my project. As this project will form the core of all my working and learning throughout the Summer.

• My college reopens on July 18 but for the first month I would still be able to devote around 40 hours, since there would be no tests/exams. I can continue with same promptness.

Commmunity Bonding Period - Week 1 (22 April - 29 May)

Goal: Community Bonding

• I will have end term examination till last week of April, thereafter I will be productive and can start right away. My principle focus will be to discuss more about the project with mentors and also to figure out how to make more improvement in the `DiracDelta` and `Heaviside`.
• This will be a great time to get to know everybody and the fellow students.
• I would also start coding in this period, so that I get a head-start and also to compensate the work to be done during my vacation days. I will spend 3-4 hours extra in the last week of the community bonding period in order to achieve the proposed target in my proposal. I will have no problem managing with those extra hours since I will be having Summer break at that time and along with that I have no other commitments. And I will also have fun working those extra hours.
• I will fix the issue related with `integrate(f(x)*DiracDelta(x-a, n), (x, -oo, oo))` and rename the `simplify()` method under `DiracDelta` class by this time.

Week 2 (30 May - 5 June)

Goal: Implement `rewrite_as_piecewise`

• This week will be dedicated to implement the continous piecewise functionality in `DiracDelta` to represent it into a Piecewise form as mentioned in the plan.
• I would also check if any other improvements are required else I can proceed towards the second phase of my project.
• I will be writing the tests along with the development. I will also prefer to document the new added functionalities.

Week 3 (6 June - 12 June)

Goal: Representation of Singularity Function

• By the starting of this week we will be having a fully functional `HeaviSide` and `DiracDelta` class with almost all of its properties implemented.
• I will use them to represent a singularity function by implementing the class `SingularityFunction`. I would follow the algorithm mentioned earlier to generate a singularity function. I will add print functions to represent it.
• I will write tests as well the documentation of the newly implemented functionalites.

Week 4 (13 June - 20 June)

• By this time, I can define any singularity functions and print them.
• I would start implementing additon, aubstraction of singularity functions along with writing tests for these functions.
• If time permits then I would start with the Differentiation part.

Week 5 - Week 6 (21 June - 5 July)

Goal: Implementing Differentiation, Integration and Continous Piecewise

• This week involves working with Differentiation at first along with writing its tests.
• Further I will move on for Integrating the singularity functions which would probably be easy to implement.
• On the later days of these two weeks I would like to implement the Continous Piecewise functionality along with fixing bugs, if any, in the whole singularity functions module.
• I would like to add documents for each and every functionalities.
• By the end of this time, I will have a fully functional Singularity Function Module which can be further used.

Till Mid Term evaluation I will have implemented upto Integration of Singularity Functions. This is my minimum target. If possible then I will move on to implementing Continous Piecewise functionality before or during mid term.

Week 7 - Week 8 (6 July - 19 July)

• This week I would start with implementing Beam Bending Module. I will import the singularity function module.
• Following that, I would start with creating the initial phase of `Beam` class, `DistributedLoad` and `PointLoad` classes too. I will then implement the `apply` method under `Beam` class. `apply` will then store the loads in some dynamically created attributes under the beam object.
• I will be writing tests along with all the functionalities.
• By this week, the beam bending module can define a beam, a distributed load, a point load and also can apply any load to the beam.

Week 9 - Week 11 (20 July - 9 Aug)

Goal: Complete the Implementation part of Beam Bending Module.

• I would continue the work of the previous weeks. I will focus on creating a singularity function expression from the stored information of the loads. `LoadDistribution` would output that singularity function expression.
• Once I am done with `LoadDistribution`, I will work on implementing `ShearForce` and `BendingMoment`.
• The rest of the time I will devote to implement `BoundaryConditions`, `Slope`, `Deflection`.
• I will write tests for these implemented functionality. I will fix the bugs and issues.
• By the end of this time, I will have successfully implemented a Singularity Funtion module and a Beam Bending Module.

Week 12 - Week 13 (10 Aug - 24 Aug)

Goal: Buffer Period and Wrap Up

This week would be a compensation for everything that might delay the completion. This will mostly involve :

• Complete Phase IV : Preparing a documentation of examples and tutorials for both the implemented modules. As I have mentioned earlier, a user would use a software more if its documentation is having plenty of examples and tutorials depicting the uses of each and every functionality.
• Finish pending tasks as this week is the buffer.
• I will be cleaning up the code and refactoring and fix bugs.

### Post GSoC :

• I will be fixing bugs and reviewing pull requests in Sympy and would look after the work done by me.
• I am very enthusiastic to learn and work for a open source community.

# References

##### Clone this wiki locally
You can’t perform that action at this time.
Press h to open a hovercard with more details.