Seno | The objective is to put projectiles | Game Engine library

When I entry 2+3 and Enter, the .exe file suddenly closes.

Several things are going on here:

1. "2+3" is not valid input to your program. Your grammar's start symbol is Calculadora, and the only production for that consists of one TKN_ID token. The first token your lexer will return for the given input will be a TKN_NUM corresponding to the 2. A parse error will result, yyparse() will return, and the program will soon terminate.

2. The way you are launching your program, Windows closes the window in which it runs as soon as the program terminates. You should be able to avoid that by opening a command window, and launching your program within via the command line.

Note also that:

1. Even if your start symbol were Expresion, "2+3" still would not be valid input. a TKN_NUM would still be the first token. The + would be matched only by the lexer's wildcard pattern, which has an empty action, so it will be printed but not produce a token. Then there will be another TKN_NUM, but the grammar has no rule that it can apply to two consecutive TKN_NUM tokens.

My cobol is not gnu, but you can do something like

Overall, you've got the right idea, but there are several issues. When trying to debug like this, you should include verbose output during each loop iteration to try to track down exactly what's happening. The problems I found are:

• You must compare the tolerance to the magnitude of serie. The Taylor series of sin includes negative terms, and the first negative term is causing your loop to exit (on the second one, every time).
• The tolerance you set is actually 0. 10**(-15) contains only integers, so the answer is evaluated as an integer. Use 10.**(15), or better yet 1.e-15.
• Your program name cannot have spaces, at least for my version of gfortran and ifort. Edit: apparently this is because I copied your code into free form, thanks francescalus
• To make sure the while loop is entered the first time, before any series is evaluated, define serie to some large value.

In addition, I have the following other recommendations:

• Do not use non-portable kind modifiers such as real*8. Depending on the system, you will get different answers. Select your kind using, for example, REAL_SELECTED_KIND or REAL64. Because you're requesting a given tolerance, the best thing to do is request that tolerance of your real kinds.
• Similarly, do not use datan and dsin - using the generic function instead will be kind-independent and will evaluate to the precision of the variable it's given.
• Instead of setting the factorial to 1 at the end of the loop, which requires a separate initialization, just set it right before the loop to compute the factorial.
• You do not need 8-byte integers here.
• Just because the last term is less than a tolerance doesn't necessarily mean the series is converged to that tolerance. The sum of many terms could give you a problem, although this is probably not a problem for sin series that converge rapidly.
• Unit 5 is usually the standard input but not always. read(*,... will connect to the standard input, or use INPUT_UNIT from ISO_FORTRAN_ENV.
• What is xteste used for? Is it supposed to be xtest?
• Set variables that shouldn't change, such as pi and tolerance, to parameters.
• Comment your code! It's not very readable right now. Think about what you would think if you came back to it in a year. I've also kept the debugging output I used to check that the code is working. This kind of output is good for beginners to learn.

All told, your fixed program looks like:

You could use Newtonsoft to serialize the class to a file.

If you have an instance of GLogInfo object (myObj), the code would look like:

The error is quite self-explaining. In your first model, you write:

To perform calculation with very long precision, you need some library for arbitrary precision arithmetics - use Delphi wrapper/interface to GMP or some Delphi library. Example. Another one.

Note that for libraries with only long integers support (not floats) you still can calculate series like this Python code (it has internal support for big integers. ** is power, // is div).
The only division (slow operation) is performed once.

What about df['Self_Employed'] = df['Self_Employed'].fillna(calc())?

I would prefer to use interpolate.splev instead of interp1d because apart from providing interpolations, the former also allows to compute derivatives easily with just a simple argument der=n where n is the order of derivative. I had to do only minor changes to your code to make things work.

Below I am only showing the relevant lines of code which I added/modified (highlighted by a comment) and the resulting plot is attached. The red dashed line is the required derivative which is comparable to the cosine function.

The problem is that you are using .eps extension, so you should use the following code.