How to convert a code from C language to Matlab

30 views (last 30 days)
EROL EREN GÖZLÜ
EROL EREN GÖZLÜ on 5 May 2019
Edited: Walter Roberson on 14 Jan 2022
#include <math.h>
#include <stdio.h>
/*********************************************************************
*
*
* Name: mag_est.c
*
* Synopsis:
*
* Demonstrates and tests the "Alpha * Min + Beta * Max" magnitude
* estimation algorithm.
*
* Description:
*
* This program demonstrates the "Alpha, Beta" algorithm for
* estimating the magnitude of a complex number. Compared to
* calculating the magnitude directly using sqrt(I^2 + Q^2), this
* estimation is very quick.
*
* Various values of Alpha and Beta can be used to trade among RMS
* error, peak error, and coefficient complexity. This program
* includes a table of the most useful values, and it prints out the
* resulting RMS and peak errors.
*
* Copyright 1999 Grant R. Griffin
*
* The Wide Open License (WOL)
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without
* fee, provided that the above copyright notice and this license
* appear in all source copies. THIS SOFTWARE IS PROVIDED "AS IS"
* WITHOUT EXPRESS OR IMPLIED WARRANTY OF ANY KIND. See
* http://scopeplot.com/dg/wol.htm for more information.
*
*********************************************************************/
/********************************************************************/
double alpha_beta_mag(double alpha, double beta, double inphase,
double quadrature)
{
/* magnitude ~= alpha * max(|I|, |Q|) + beta * min(|I|, |Q|) */
double abs_inphase = fabs(inphase);
double abs_quadrature = fabs(quadrature);
if (abs_inphase > abs_quadrature) {
return alpha * abs_inphase + beta * abs_quadrature;
} else {
return alpha * abs_quadrature + beta * abs_inphase;
}
}
/*********************************************************************/
double decibels(double linear)
{
#define SMALL 1e-20
if (linear <= SMALL) {
linear = SMALL;
}
return 20.0 * log10(linear);
}
/*********************************************************************/
void test_alpha_beta(char *name, double alpha, double beta,
int num_points)
{
#define PI 3.141592653589793
int ii;
double phase, real, imag, err, avg_err, rms_err;
double peak_err = 0.0;
double sum_err = 0.0;
double sum_err_sqrd = 0.0;
double delta_phase = (2.0 * PI) / num_points;
for (ii = 0; ii < num_points; ii++) {
phase = delta_phase * ii;
real = cos(phase);
imag = sin(phase);
err = sqrt(real * real + imag * imag)
- alpha_beta_mag(alpha, beta, real, imag);
sum_err += err;
sum_err_sqrd += err * err;
err = fabs(err);
if (err > peak_err) {
peak_err = err;
}
}
avg_err = sum_err / num_points;
rms_err = sqrt(sum_err_sqrd / num_points);
printf("%-16s %14.12lf %14.12lf %9.6lf %4.1lf %4.1lf\n",
name, alpha, beta, avg_err, decibels(rms_err),
decibels(peak_err));
}
/*********************************************************************/
void main(void)
{
#define NUM_CHECK_POINTS 100000
typedef struct tagALPHA_BETA {
char *name;
double alpha;
double beta;
} ALPHA_BETA;
#define NUM_ALPHA_BETA 16
const ALPHA_BETA coeff[NUM_ALPHA_BETA] = {
{ "Min RMS Err", 0.947543636291, 0.3924854250920 },
{ "Min Peak Err", 0.960433870103, 0.3978247347593 },
{ "Min RMS w/ Avg=0", 0.948059448969, 0.3926990816987 },
{ "1, Min RMS Err", 1.0, 0.323260990 },
{ "1, Min Peak Err", 1.0, 0.335982538 },
{ "1, 1/2", 1.0, 1.0 / 2.0 },
{ "1, 1/4", 1.0, 1.0 / 4.0 },
{ "Frerking", 1.0, 0.4 },
{ "1, 11/32", 1.0, 11.0 / 32.0 },
{ "1, 3/8", 1.0, 3.0 / 8.0 },
{ "15/16, 15/32", 15.0 / 16.0, 15.0 / 32.0 },
{ "15/16, 1/2", 15.0 / 16.0, 1.0 / 2.0 },
{ "31/32, 11/32", 31.0 / 32.0, 11.0 / 32.0 },
{ "31/32, 3/8", 31.0 / 32.0, 3.0 / 8.0 },
{ "61/64, 3/8", 61.0 / 64.0, 3.0 / 8.0 },
{ "61/64, 13/32", 61.0 / 64.0, 13.0 / 32.0 }
};
int ii;
printf("\n Alpha * Max + Beta * Min Magnitude Estimator\n\n");
printf("Name Alpha Beta Avg Err RMS Peak\n");
printf(" (linear) (dB) (dB)\n");
printf("---------------------------------------------------------------------\n");
for (ii = 0; ii < NUM_ALPHA_BETA; ii++) {
test_alpha_beta(coeff[ii].name, coeff[ii].alpha, coeff[ii].beta, 1024);
}
}
  4 Comments
Show 2 older comments
Guillaume
Guillaume on 6 May 2019
@erol, why can't you convert it yourself. There is nothing complicated about that code. You can pretty much rewrite as matlab code by copying most of it. If there's a few things you don't understand you can search for it with your favorite search engine or ask here.
More importantly, why do you want to convert it. The main of the program has fixed inputs and will always produce the same output. That doesn't strike me as very useful.

Sign in to comment.

Sign in to answer this question.

Accepted Answer

Jan
Jan on 6 May 2019
Edited: Jan on 6 May 2019
Try this one - it is not debugged and written in the forum's interface:
function main
NUM_CHECK_POINTS = 100000;
coeff = { ...
'Min RMS Err', 0.947543636291, 0.3924854250920; ...
'Min Peak Err', 0.960433870103, 0.3978247347593; ...
'Min RMS w/ Avg=0', 0.948059448969, 0.3926990816987; ...
'1, Min RMS Err', 1.0, 0.323260990; ...
'1, Min Peak Err', 1.0, 0.335982538; ...
'1, 1/2', 1.0, 1.0 / 2.0 ; ...
'1, 1/4', 1.0, 1.0 / 4.0 ; ...
'Frerking', 1.0, 0.4 ; ...
'1, 11/32', 1.0, 11.0 / 32.0; ...
'1, 3/8', 1.0, 3.0 / 8.0 ; ...
'15/16, 15/32', 15.0 / 16.0, 15.0 / 32.0; ...
'15/16, 1/2', 15.0 / 16.0, 1.0 / 2.0 ; ...
'31/32, 11/32', 31.0 / 32.0, 11.0 / 32.0; ...
'31/32, 3/8', 31.0 / 32.0, 3.0 / 8.0 ; ...
'61/64, 3/8', 61.0 / 64.0, 3.0 / 8.0 ; ...
'61/64, 13/32', 61.0 / 64.0, 13.0 / 32.0};
fprintf('\n Alpha * Max + Beta * Min Magnitude Estimator\n\n');
fprintf('Name Alpha Beta Avg Err RMS Peak\n');
fprintf(' (linear) (dB) (dB)\n');
printf('---------------------------------------------------------------------\n');
for ii = 1:size(coeff, 1)
test_alpha_beta(coeff{ii, 1}, coeff{ii, 2}, coeff{ii, 3}, 1024);
end
end
function R = alpha_beta_mag(alpha, beta, inphase, quadrature)
% magnitude ~= alpha * max(|I|, |Q|) + beta * min(|I|, |Q|) */
abs_inphase = abs(inphase);
abs_quadrature = abs(quadrature);
if abs_inphase > abs_quadrature
R = alpha * abs_inphase + beta * abs_quadrature;
else
R = alpha * abs_quadrature + beta * abs_inphase;
end
end
function R = decibels(linear)
R = 20.0 * log10(max(1e-20, linear));
end
function R = test_alpha_beta(name, alpha, beta, num_points)
peak_err = 0.0;
sum_err = 0.0;
sum_err_sqrd = 0.0;
delta_phase = (2.0 * Ppi) / num_points;
for ii = 0:num_points - 1
phase = delta_phase * ii;
real = cos(phase);
imag = sin(phase);
err = sqrt(real * real + imag * imag) ...
- alpha_beta_mag(alpha, beta, real, imag);
sum_err = sum_err + err;
sum_err_sqrd = sum_err_sqrd + err * err;
err = abs(err);
if (err > peak_err)
peak_err = err;
end
end
avg_err = sum_err / num_points;
rms_err = sqrt(sum_err_sqrd / num_points);
fprintf('%-16s %14.12f %14.12f %9.6f %4.1f %4.1f\n',
name, alpha, beta, avg_err, decibels(rms_err),
decibels(peak_err));
end
It took 2 minutes to convert is from C to Matlab.

More Answers (1)

Dilshana O
Dilshana O on 7 Jun 2021
Hei plzz convert this c code into matlab code #include<stdio.h> void main(){
float p1,p2,p3; float delta=1; scanf("%f%f%f",&p1,&p2,&p3); float d = p2; if(p1 != p2) { if(p1>p2) { if(p2>p3) { d=d-delta; delta=delta*2; } else if(p2=p3) { d=d-delta; delta=delta*2; } else { delta=delta/2; } } else { if(p3>p2) { d=d+delta; delta=delta*2; } else if(p2=p3) { d=d+delta; delta=delta*2; } else { delta=delta/2; } } } else if(p1==p2) { if(p2>p3) { if(p2>p3) { d=d-delta; delta=delta/2; } else if(p2<p3) { d=d-delta; delta=delta*2; } else { delta=delta*2; } } }
}
  3 Comments
Show 1 older comment
Mohsen momenitabar
Mohsen momenitabar on 14 Jan 2022
Edited: Walter Roberson on 14 Jan 2022
Hi Everyone, I have a c++ code and i need to convert it to MATLAB code. Here is my code:
Thanks,
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define mem(list, val) memset(list, (val), sizeof(list))
#define pb push_back
typedef vector<int> _Route;
typedef vector<vector<int> > _RouteSet;
typedef vector<vector<double> > Matrix;
#define MAX 200
#define INF 1e8
enum status {NEW_ROUTE_ADDED, SIZE_OVERFLOW, NO_PATH};
int minRouteSize, maxRouteSize;
vector<double> popularity;
struct node{
int id;
double dist;
node(int i, double w){
id = i;
dist = w;
}
friend bool operator<(const node& l, const node& r)
{
return l.dist > r.dist; // since default pq is max pd
}
};
void readData(string filename, Matrix &matrix)
{
FILE *fp = fopen(filename.c_str(), "r");
int siz, num;
fscanf(fp, "%d", &siz);
vector<double> temp;
for(int i=0; i<siz; i++){
for(int j=0; j<siz; j++){
fscanf(fp, "%d", &num);
temp.push_back((double)num);
}
matrix.push_back(temp);
temp.clear();
}
fclose(fp);
}
template<class T>
void print_matrix(vector<vector<T> > &m)
{
int d = m.size();
for(int i = 0; i < d; i++) {
int l = m[i].size();
for(int j = 0; j < l; j++) {
printf("%f ", m[i][j]);
}
printf("\n");
}
}
pair<int, int> getHighestDemandPair(Matrix &demand)
{
int from, to;
double maxDemand = 0;
for(int i=0; i<demand.size(); i++){
for(int j=0; j<demand[i].size(); j++){
if(demand[i][j] > maxDemand){
from = i, to = j, maxDemand = demand[i][j];
}
}
}
//cout << "check: " << from << ' ' << to << ' ' << maxDemand << endl;
return make_pair(from, to);
}
int highestDemandDestination(int from, Matrix &demand)
{
int ret;
double maxDemand = -INF;
for(int i=0; i<demand[from].size(); i++){
if(demand[from][i] > maxDemand){
maxDemand = demand[from][i];
ret = i;
}
}
return ret;
}
double normalize(Matrix &mat)
{
double mx = 0;
for(int i=0; i<mat.size(); i++){
auto it = max_element(begin(mat[i]), end(mat[i]));
mx = max(mx, *it);
}
if(mx == 0) return 0;
for(int i=0; i<mat.size(); i++){
for(int j=0; j<mat[i].size(); j++){
if(mat[i][j] == -1 || mat[i][j] == 0) mat[i][j] = INF; ///for no edge case
else mat[i][j] /= mx;
}
}
return mx;
}
status getBestRoute(int from, int to, Matrix &distance, Matrix &demand, _Route &ret, double dw)
{
//cout << "from: " << from << " to: " << to << " demand: " << demand[from][to] << endl;
Matrix tempDist = distance, tempDemand = demand;
normalize(tempDemand); ///normalize demands
normalize(tempDist); ///normalize distance
///transform to fit shortest path problem
for(int i=0; i <tempDist.size(); i++) {
for(int j=0; j<tempDist[i].size(); j++) {
if(tempDist[i][j] <= 1.0) tempDist[i][j] = (1 - dw) * tempDist[i][j] + dw * 0.5 * (1/(tempDemand[i][to]+1) + 1/(tempDemand[j][to]+1));
}
}
int numberOfNodes = distance.size();
double djDist[numberOfNodes+1], parent[numberOfNodes+1];
for(int i=0; i<numberOfNodes; i++){
djDist[i] = INF;
parent[i] = -1;
}
djDist[from] = 0; ///path cost = distance + 1/(demand + 1)
priority_queue<node> Q;
Q.push(node(from, djDist[from]));
bool dequed[numberOfNodes+1];
mem(dequed, false);
while(!Q.empty()){
int fr = Q.top().id;
//cout << fr <<endl;
if(fr == to) break;
if(dequed[fr]){
Q.pop();
continue;
}
djDist[fr] = Q.top().dist;
dequed[fr] = true;
Q.pop();
for(int i=0; i<tempDist[fr].size(); i++){
if(tempDist[fr][i] >= 1e6 || fr == i) continue;
if(djDist[i] > djDist[fr] + tempDist[fr][i]){
djDist[i] = djDist[fr] + tempDist[fr][i];
parent[i] = fr;
Q.push(node(i, djDist[i]));
}
}
}
if(parent[to] == -1){ //no path
//cout << "no path\n";
return NO_PATH;
}
_Route temp;
int cur = to;
temp.push_back(cur);
while(cur != from){
cur = parent[cur];
temp.push_back(cur);
}
//for(int i=temp.size()-1; i>=0; i--) cout << temp[i] << ' ' ;
//cout << endl;
if(ret.size() + temp.size() -1 <= maxRouteSize){
assert(temp.size() != maxRouteSize + 1);
if(ret.size()) ret.pop_back();
ret.insert(ret.end(), temp.rbegin(), temp.rend());
return NEW_ROUTE_ADDED;
}
return SIZE_OVERFLOW;
}
bool recur(Matrix &distance, Matrix &demand, Matrix &choice, _Route &route, double dw, int from, int to = -1) ///generates a single route
{
//getchar();
if(choice[from][to] <= 0 || demand[from][to] <= 0){
//cout << "No demand left\n";
return (route.size() >= minRouteSize && route.size() <= maxRouteSize); ///no more demand left
}
status ret = getBestRoute(from, to, distance, demand, route, dw); ///add a route (part)
if(ret == SIZE_OVERFLOW){
//cout << "size overflow\n";
return (route.size() >= minRouteSize && route.size() <= maxRouteSize);
}
if(ret == NO_PATH){
//cout << "no path between " << from << ' ' << to << " demand: " << choice[from][to] << endl;
choice[from][to] = 0;
choice[to][from] = 0;
to = highestDemandDestination(from, choice);
return recur(distance, demand, choice, route, dw, from, to);
}
//segment added to route
//cout << "route segment added\ncurrent size: " << route.size() << endl;
for(int i=0; i<route.size(); i++){
for(int j=0; j<route.size(); j++){
demand[route[i]][route[j]] = 0;
choice[route[i]][route[j]] = 0;
}
}
for(int i=0; i<route.size(); i++){
int ind = route[i];
for(int j=0; j<distance[ind].size(); j++) distance[j][ind] = -1;
}
from = to;
to = highestDemandDestination(from, choice);
return recur(distance, demand, choice, route, dw, from, to);
}
void getBestRouteSet(Matrix &dist, Matrix &demand, int numberOfRoutes, _RouteSet &RS, double dw)
{
//puts("Inside genBestRouteSet");
Matrix tempDist, tempDemand = demand, choice;
for(int i=0; i<numberOfRoutes; i++){
tempDist = dist;
choice = tempDemand;
pair<int, int> pp = getHighestDemandPair(choice);
int from = pp.first, to = pp.second;
if(popularity[from] > popularity[to]) swap(from, to);
_Route route;
bool added = recur(tempDist, tempDemand, choice, route, dw, from, to);
if(!added) i--;
else{
//cout << "route added\n";
RS.push_back(route);
}
}
///getHighestDemandPair(tempDemand);
}
bool checkRoute(const _Route &route, const Matrix &distance, int maxRouteSize, int minRouteSize)
{
/*
if(route.size() > maxRouteSize)
return false;
if(route.size() < minRouteSize)
return false;
*/
assert(route.size() >= minRouteSize && route.size() <= maxRouteSize);
int n = distance.size();
vector<bool> isInRoute(n, false);
for(int i = 0; i < route.size(); i++) {
/*
if(isInRoute[route[i]]) {
return false;
}
*/
assert(!isInRoute[route[i]]);
isInRoute[route[i]] = true;
}
for(int i = 0; i < route.size() - 1; i++) {
/*
if(distance[route[i]][route[i + 1]] == -1) {
return false;
}
*/
assert(distance[route[i]][route[i + 1]] != -1);
}
return true;
}
int main(int argc, char **argv)
{
if(argc < 7) {
printf("Usage: distances_file demands_file num_of_routes minRouteSize maxRouteSize num_of_route_sets\n");
return 1;
}
Matrix dist, demand;
readData(argv[1], dist);
readData(argv[2], demand);
minRouteSize = atoi(argv[4]);
maxRouteSize = atoi(argv[5]);
int num_of_route_sets = atoi(argv[6]);
int numberOfNodes = dist.size();
double dw_step = 1.0 / (num_of_route_sets - 1);
for(int i=0; i<numberOfNodes; i++) popularity.push_back(0);
for(int i=0; i<numberOfNodes; i++){
for(int j=0; j<numberOfNodes; j++) popularity[i] += demand[j][i];
}
//cout << minRouteSize << endl;
//print_matrix<double>(dist);
//print_matrix<double>(demand);
for(int r = 0; r < num_of_route_sets; r++)
{
//printf("generating %d\n", r);
_RouteSet result;
double dw = r * dw_step;
getBestRouteSet(dist, demand, atoi(argv[3]), result, dw);
for(int i=0; i<result.size(); i++){
if(!checkRoute(result[i], dist, maxRouteSize, minRouteSize)) {
printf("Route is dangerous %d \n", i);
}
for(int j=0; j<result[i].size(); j++) cout << result[i][j] << ' ';
cout << "-1\n";
}
cout << "\n";
}
return 0;
}
Rik
Rik on 14 Jan 2022
@Mohsen, you must be joking.
Have a read here and here. It will greatly improve your chances of getting an answer.
This answer (including your comment) will be deleted shortly.

Sign in to comment.

Categories

Find more on Signal Operations in Help Center and File Exchange

Tags

Community Treasure Hunt

Find the treasures in MATLAB Central and discover how the community can help you!

Start Hunting!