User:Karthik0112358/Coefficient Calculator - Revision history

Karthik0112358 at 23:01, 4 August 2011

2011-08-04T23:01:13Z

← Older revision		Revision as of 23:01, 4 August 2011
Line 294:		Line 294:

	void coefficient_match(double coefficient,struct Info_abt_deriv Info,int order,double num,double var,double func,int ope, unsigned long length_rel){		void coefficient_match(double coefficient,struct Info_abt_deriv Info,int order,double num,double var,double func,int ope, unsigned long length_rel){
	int i,j,k;		int i,j,k,p;
	double value;		double value;
	int flag;		int flag;
Line 310:		Line 310:
	case 2:		case 2:
	++varc;		++varc;
	if(Info.deriv_values[i]==var[varc]) {		/*if(Info.deriv_values[i]==var[varc]) {
	if(order[j-1]==1&&order[j+1]==3) {		if(order[j-1]==1&&order[j+1]==3) {
	if(ope[opec+1]==3) {		if(ope[opec+1]==3) {
Line 327:		Line 327:
	}		}
	}		}
	}		}*/
			/*
			We write here a piece of code which sees the relation as follows:
			(i) the variable whose coefficient we have to find is replaced by 1.
			(ii) every other variable is replaced by 0.
			(iii) we simplify the expression we have but with certain new rules:
			(iii) (i) If + or - operator is encountered then we replace the number preceeding or succeeding it by 0.
			(iii) (ii) If ^ is encountered we ignore it and the number following it(which has to be 1).
			*/
			for(p=0;order[p]!=4;p++) {
			/* Implement above algorithm here*/
			\ }
	break;		break;
	case 3:		case 3:

Karthik0112358 at 22:39, 31 July 2011

2011-07-31T22:39:00Z

@@ Line 193: / Line 193: @@
 /* So here it begins */
 static int Inspect_Equation(struct Info_abt_deriv Info,int *order,double *var,double *func,int *ope,unsigned long length_rel){
-	double var_index;
+	int result;
 	char *left_bin_num,*right_bin_num;
-	left_bin_num=find_left_bin_number(order,length_rel);
+	int *len_left_bin_num,*len_right_bin_num; /* Pointers are used so that these can be passed by reference */
-	right_bin_num=find_right_bin_number(order,length_rel);
+	left_bin_num=ASC_NEW_ARRAY(char,length_rel);
 /* We write here an inspection for special cases, like : 3=4+Q(x,y)/x, where is Q(x,y) is a linear function in x */
@@ Line 216: / Line 236: @@
 				var_index=find_variable(Info,var[varc]);
 				if(var_index!=0){
+					result+=check_in denominator(left_bin_num,len_left_bin_num,right_bin_num,len_right_bin_num,var_index,flag);
+				}
 				break;
@@ Line 230: / Line 255: @@
+		}
+	}
-	return 1;
+	return (result>0)?0:1;
+}

Karthik0112358 at 21:02, 25 July 2011

2011-07-25T21:02:10Z

← Older revision		Revision as of 21:02, 25 July 2011
Line 130:		Line 130:
	by using a variable to point at the location of the derivative in a binary representation of the		by using a variable to point at the location of the derivative in a binary representation of the
	relation where 0 means a number or variable and 1 means an operator. Then we display an error is		relation where 0 means a number or variable and 1 means an operator. Then we display an error is
	the derivative is raised to a higher/lower power.*/		the derivative is raised to a higher/lower power.* /
	c=0;		c=0;
	count=-1;		count=-1;
Line 138:		Line 138:
	The idea is to locate every ^ operator and see if the item immediately following		The idea is to locate every ^ operator and see if the item immediately following
	it in the infix notation is 1 which does not have any prior connection with any other		it in the infix notation is 1 which does not have any prior connection with any other
	operator. */		operator. * /
	/* As a second thought, I think I will segregate each Error case as a function, considering the recursive algorithms used in some of the cases. */		/* As a second thought, I think I will segregate each Error case as a function, considering the recursive algorithms used in some of the cases. * /
	if(flag==0){		if(flag==0){
	while(order[c]!=4){		while(order[c]!=4){
Line 183:		Line 183:
	break;		break;
	default:		default:
	/* Give Error Message */		/* Give Error Message * /
	break;		break;
	}		}

Karthik0112358 at 20:59, 25 July 2011

2011-07-25T20:59:48Z

Show changes

Karthik0112358 at 10:58, 30 June 2011

2011-06-30T10:58:26Z

@@ Line 73: / Line 73: @@
+       }
        term = NewRelationTerm(r, t++, lhs);
 // Here I need something to take data from relation_term structure's term and pass it to Classify_Var() which accepts var_variable structure.
 // Let me assume its done. Let me call it info.
@@ Line 88: / Line 89: @@
 // Error message for higher order derivatives.
+          }
+       }
+    }

Karthik0112358 at 00:49, 25 June 2011

2011-06-25T00:49:32Z

← Older revision		Revision as of 00:49, 25 June 2011
Line 89:		Line 89:
	}		}
	}		}
			}
			#undef grad_stack
			#undef res_stack
	}		}
	</source>		</source>

Karthik0112358 at 00:46, 25 June 2011

2011-06-25T00:46:24Z

← Older revision		Revision as of 00:46, 25 June 2011
Line 1:		Line 1:
	<source lang="c">		<source lang="c">
			#define INTEG_OTHER_VAR -1L
			#define INTEG_ALGEBRAIC_VAR 0L
			#define INTEG_STATE_VAR 1L
	int Coefficient_Calculator(struct Instance i,double coefficient){		int Coefficient_Calculator(struct Instance i,double coefficient){
	struct relation *r;		struct relation *r;
	enum Expr_enum reltype;		enum Expr_enum reltype;
	int dummy_int;		int dummy_int;
			long index, type;
	r = (struct relation *)GetInstanceRelation(i, &reltype);		r = (struct relation *)GetInstanceRelation(i, &reltype);
	if( r == NULL ) {		if( r == NULL ) {
Line 68:		Line 72:
	}		}
	}		}
	//~~more~~ to ~~write~~		term = NewRelationTerm(r, t++, lhs);
			// Here I need something to take data from relation_term structure's term and pass it to Classify_Var() which accepts var_variable structure.
			// Let me assume its done. Let me call it info.
			type = Classify_Var(info,&index);
			if(type==INTEG_ALGEBRAIC_VAR){
			// It is an algebraic variable (solver variable)
			}else if(type==INTEG_OTHER_VAR){
			// It is an independent variable
			}else if(type>=INTEG_STATE_VAR){
			if(type == 1){
			// It is one of the states.One of y_i
			}else if(type == 2){
			// Detects it as first order derivative. Write suitable code for determining coefficient here.
			}else{
			// Error message for higher order derivatives.
			}
			}
	}		}
	</source>		</source>

Karthik0112358: Created page with ' int Coefficient_Calculator(struct Instance i,double coefficient){ struct relation *r; enum Expr_enum reltype; int dummy_int; r = (struct relation …'

2011-06-22T02:15:12Z

Created page with '<source lang="c"> int Coefficient_Calculator(struct Instance *i,double *coefficient){ struct relation *r; enum Expr_enum reltype; int dummy_int; r = (struct relation …'

New page

<source lang="c">
int Coefficient_Calculator(struct Instance *i,double *coefficient){
struct relation *r;
enum Expr_enum reltype;
int dummy_int;
r = (struct relation *)GetInstanceRelation(i, &reltype);
if( r == NULL ) {
ERROR_REPORTER_HERE(ASC_PROG_ERR,"null relation\n");
return -1;
}
// the current term in the relation r
unsigned long t;
// the number of variables in the relation r
unsigned long num_var;
// the index of the variable we are looking at
unsigned long v;
// looking at left(=1) or right(=0) hand side of r
int lhs;
// the memory for the stacks
double *stacks;
// height of each stack
unsigned long stack_height;
// the top position in the stacks
long s = -1;
unsigned long length_lhs, length_rhs;
CONST struct relation_term *term;
CONST struct Func *fxnptr;
num_var = NumberVariables(r);
length_lhs = RelationLength(r, 1);
length_rhs = RelationLength(r, 0);
if( (length_lhs + length_rhs) == 0 ) {
for( v = 0; v < num_var; v++ ) coefficient[v] = 0.0;
*residual = 0.0;
return 0;
}
else {
stack_height = 1 + MAX(length_lhs,length_rhs);
}
//creating stacks
stacks = tmpalloc_array(((num_var+1)*stack_height),double);
if( stacks == NULL ) return 1;
#define res_stack(s) stacks[(s)]
#define coeff_stack(v,s) stacks[((v)*stack_height)+(s)]
lhs = 1;
t = 0;
while(1) {
if( lhs && (t >= length_lhs) ) {
if( length_rhs ) {
lhs = t = 0;
}
else {
for( v = 1; v <= num_var; v++ ) coefficient[v-1] = coeff_stack(v,s);
return 0;
}
}
else if( (!lhs) && (t >= length_rhs) ) {
if( length_lhs ) {
for( v = 1; v <= num_var; v++ ) {
coefficient[v-1] = coeff_stack(v,s-1) - coeff_stack(v,s);
}
return 0;
}
else {
for( v = 1; v <= num_var; v++ ) {
coefficient[v-1] = -coeff_stack(v,s);
}
return 0;
}
}
//more to write
}
</source>