D3 is great at data visualizations, but it manipulates the DOM directly to display that data. Rendering DOM elements is where React shines. It uses a virtual representation of the DOM (virtual DOM) and a super performant diffing algorithm in order to determine the fastest way to update the DOM. We want to leverage React’s highly efficient, declarative, and reusable components with D3’s data utility functions.

At this point, we can safely say that React is the preferred JavaScript library for building user interfaces. It is used practically everywhere and is almost as pervasive as jQuery. It has an API that is simple, powerful, and easy to learn. Its performance metrics are really impressive thanks to the Virtual DOM and its clever diff algorithm between state changes. Nothing, however, is perfect, and React too has its limitations. One of React’s greatest strengths is the ease with which it integrate third-party libraries, but some libraries, especially opinionated ones, are more difficult to integrate than others.

An extremely popular library that can be tricky to integrate with React is D3.js. D3 is an excellent data visualization library with a rich and powerful API. It is the gold standard of data visualizations. However, Because this library is opinionated about data, it is no trivial endeavour to get it to work with React. A few simple strategies permit these two libraries to work together in very powerful ways.

Editor’s Note: Check out our upcoming workshop, React and D3, a crash course in learning how to create data visualizations with these two in demand libraries. Reserve your spot now on Eventbrite and get 20% off admission. Learn more at the Eventbrite page

What is React?

React is an open-source JavaScript library for creating user interfaces that addresses the challenges of building large applications with data that changes over time. Originally developed at Facebook, it is now seen in many of the most commonly used web applications including Instagram, Netflix, Airbnb, and HelloSign.

Why is React so popular?

React helps developers build applications by helping manage the application state. It’s simple, declarative, and composable. React is not a traditional MVC framework because React is really only interested in building user interfaces. Some have called it the “V(iew)” in MVC, but that’s a little misleading. React’s viewpoint is different. As application logic has reoriented toward the client, developers have applied more structure to their front-end JavaScript. We applied a paradigm that we already understood from the server (MVC) to the browser. Of course, the browser environment is very different from the server. React acknowledges that client-side applications are really a collection of UI components that should react to events like user interaction.

React encourages the building applications out of self-contained, reusable components that only care about a small piece of the UI. Other frameworks such as Angular also attempt to do this, but React stands out because it enforces a unidirectional data flow from parent component to child component. This makes debugging much easier. Debugging is the hardest part of application development, so while React is more verbose that other libraries or frameworks, in the end it saves a lot of time. In a framework like Angular’s, it can be hard to figure out where a bug is coming from: The view? The model? The controller? The directive? The directive controller? Data in Angular flows in many different directions, and this makes it hard to reason about that state of your application. In React, when there is a bug (and there will be!), you can quickly determine where the bug originated from because data only moves in one direction. Locating a bug is as simple as connecting the numbered dots until you find the culprit.

What is D3?

D3 (Data-Driven Documents) is a JavaScript library for producing dynamic, interactive data-visualizations. It’s fairly low level, and the developer has a lot of control over the end result. It takes a bit of work to get D3 to do what you want, so if you’re looking for a more prepackaged solution, you’re probably better off with highcharts.js. That said, it is fairly simple to pick up once you get the hang of it.

D3 does four main things:

1. LOADS: D3 has convenient methods for importing data from CSV documents.
2. BINDS: D3 binds data elements to the DOM via JavaScript and SVG.
3. TRANSFORMS: data can be adjusted to fit your visual requirements
4. TRANSITIONS: D3 can respond to user input and animate elements based on that input

Why Would We Want To Use React with D3?

D3 is great at data visualizations, but it manipulates the DOM directly to display that data. Rendering DOM elements is where React shines. It uses a virtual representation of the DOM (virtual DOM) and a super performant diffing algorithm in order to determine the fastest way to update the DOM. We want to leverage React’s highly efficient, declarative, and reusable components with D3’s data utility functions. Also, once we create a chart component, we can want to be able to reuse that chart with different data anywhere in our app.

How to use React and D3?

D3, like React, is declarative.D3 uses data binding, whereas React uses a unidirectional data flow paradigm. Getting these two libraries to work together takes a bit of work, but the strategy is fairly simple: since SVG lives in the DOM, let React handle displaying SVG representations of the data and lett D3 handle all the math to render the data.

Of course, we’ll have to make compromises. React is unopinionated and flexible, thereby allowing you to accomplish whatever needs to be done. Some tasks, like creating axes, are tedious. We can let D3 directly access the DOM and create. It handles axes well, and since we only need to create very few, this tactic won’t affect performance.

Let’s go through a simple example. I created a repository you can use to follow along here: playing-with-react-and-d3. You can follow in the unfinished directory and if you get stuck you can take a look at the finished directory.

Let’s generate a random list of X-Y coordinates and display them on a ScatterPlot chart. If you’re following the tutorial, a finished example is provided for you under the “finished” directory, but you can also follow along under “unfinished.” I’ve gone through the trouble of doing all the setup for you. The build will automatically be created from “unfinished/src/index.jsx”

Let’s start by creating a simple “Hello World!” React component. Create a file under “components” named “chart.jsx”

// unfinished/src/components/chart.jsx
import React from 'react';

export default (props) => {
  return <h1>Hello, World!</h1>;
}

This example is simple, but let’s go over the explanation anyway. Since we’re rendering a simple H1 with no state, we can just export a function that returns the HTML we expect. If you’re familiar with Angular or Ember, it might look weird to insert HTML directly into our JS code. On the one hand, this goes against everything we’ve learned about unobtrusive JavaScript. But on the other hand, it actually makes sense: we’re not putting JavaScript in our HTML, we’re putting our HTML into our JavaScript. React sees HTML and client-side JavaScript as fundamentally bonded together. They’re both concerned about one thing – rendering UI components to the user. They simply cannot be separated without losing the ability to see what your component is going at a glance. The great benefits of this approach is that you can describe exactly what your component will look like when it’s rendered.

Also, keep in mind that this is only possible with JSX, which translates HTML elements into React functions that will render the HTML to the page.

Now, let’s move on and mount our component to the DOM. Open up “index.jsx”

// unfinished/src/index.jsx
import './main.css';
import React    from 'react';
import ReactDOM from 'react-dom';
import Chart    from './components/chart.jsx';

const mountingPoint = document.createElement('div');
mountingPoint.className = 'react-app';
document.body.appendChild(mountingPoint);
ReactDOM.render(<Chart/>, mountingPoint);

You probably noticed a few things. You might be wondering why we’re requiring a CSS file. We’re using Webpack, which allows us to require CSS files. This is very useful when we modularize both our stylesheets and our JavaScript. We’re also creating a div in which we want to mount our React app. This is just a good practice in case you want to do other things on the page then render a React component. Lastly, we’re calling render on ReactDOM with 2 arguments, the name of the component and the DOM element we want to mount it on.

Now, let’s install all the dependencies by navigating to the unfinished directory and running npm i. Then, fire up the server with npm run start and go to localhost:8080

Awesome! We have rendered our first React component! Let’s do something a little less trivial now.

Let’s compose some functions that will create an array of random data points and then render a scatter plot. While we’re at it, we’ll add a button to randomize the dataset and trigger a re-render of our app. Let’s open up our Chart component and add the following:

// unfinished/src/components/chart.jsx
import React       from 'react';
import ScatterPlot from './scatter-plot';

const styles = {
  width   : 500,
  height  : 300,
  padding : 30,
};

// The number of data points for the chart.
const numDataPoints = 50;

// A function that returns a random number from 0 to 1000
const randomNum     = () => Math.floor(Math.random() * 1000);

// A function that creates an array of 50 elements of (x, y) coordinates.
const randomDataSet = () => {
  return Array.apply(null, {length: numDataPoints}).map(() => [randomNum(), randomNum()]);
}

export default class Chart extends React.Component{
  constructor(props) {
    super(props);
    this.state = { data: randomDataSet() };
  }

  randomizeData() {
    this.setState({ data: randomDataSet() });
  }

  render() {
    return <div>
      <h1>Playing With React and D3</h1>
      <ScatterPlot {...this.state} {...styles} />
      <div className="controls">
        <button className="btn randomize" onClick={() => this.randomizeData()}>
          Randomize Data
        </button>
      </div>
    </div>
  }
}

Since we want our component to manage it’s own state, we need to add a bit more code than was necessary for our previous “Hello World” stateless functional component. Instead of just a function, we’re going to extend React.Component and describe our component in the render() method. render() is the heart of any React component. It describes what our component is supposed to looks like. React will call render() on initial mount and on every state change.

Inside of render(), we are both rendering a scatter plot component as if it were an HTML element and setting some properties or “props”. The ... syntax is a convenient JSX and ES2015 spread operator that spreads the attributes of an array or object instead of doing all of that explicitly. For more information check out: JSX Spread Attributes. We’re going to use render() to pass our data and a style object that will be used by some of our child components.

In addition, we’re also rendering a button with an onClick event handler. We’re going to wrap this.randomizeData() with an arrow function and bind the value of this to our Chart component. When the button is clicked, randomizeData() will call this.setState() and pass in some new data.

Let’s talk about this.setState(). If render() is the heart of a React component, setState() is the brains of a component. setState explicitly tells React that we’re changing the state, thereby triggering a re-render of the component and its children. This essentially turns UI components into state machines.

Inside of setState(), we’re passing an object with data set to the randomDataSet(). This means that if we want to retrieve the state of our application, we need only call this.state.whateverStateWereLookingFor. In this case, we can retrieve the randomData by calling this.state.data.

A little side note on how React works: React offers great performance for rendering UI components by implementing a diff algorithm and comparing a virtual DOM in memory with the actual DOM. When you think about it, the DOM is really a large tree structure. If there’s one thing we have learned from decades of computer science research, it’s how to compare and manipulate trees. React takes advantage of clever tree diffing algorithms, but in order to work, each component can only render one parent element (i.e., you cannot render sibling elements). That’s why In the render function we’re wrapping all our elements in one parent div.

Let’s get started with the scatter plot component. Create a file unfinished/src/components/scatter-plot.jsx :

// unfinished/src/components/scatter-plot.jsx
import React        from 'react';
import d3           from 'd3';
import DataCircles  from './data-circles';

// Returns the largest X coordinate from the data set
const xMax   = (data)  => d3.max(data, (d) => d[0]);

// Returns the highest Y coordinate from the data set
const yMax   = (data)  => d3.max(data, (d) => d[1]);

// Returns a function that "scales" X coordinates from the data to fit the chart
const xScale = (props) => {
  return d3.scale.linear()
    .domain([0, xMax(props.data)])
    .range([props.padding, props.width - props.padding * 2]);
};

// Returns a function that "scales" Y coordinates from the data to fit the chart
const yScale = (props) => {
  return d3.scale.linear()
    .domain([0, yMax(props.data)])
    .range([props.height - props.padding, props.padding]);
};

export default (props) => {
  const scales = { xScale: xScale(props), yScale: yScale(props) };
  return <svg width={props.width} height={props.height}>
    <DataCircles {...props} {...scales} />
  </svg>
}

There’s a lot going on here, so let’s start with the stateless functional component that we’re exporting. D3 uses SVG to render data visualizations. D3 has special methods for creating SVG elements and binding data to those elements – but we’re going to let React handle that. We’re creating an SVG element with the properties passed in by the Chart component and which can be accessed via this.props. Then we’re creating a DataCircles component (more on that below) which will render the points for the scatter plot.

Let’s talk about D3 scales. This is where D3 shines. Scales takes care of the messy math involved in converting your data into a format that can be displayed on a chart. If you have a data point value 189281, but your chart is only 200 pixels wide, then D3 scales converts that value to a number you can use.

d3.scale.linear() returns a linear scale. D3 also supports other types of scales (ordinal, logarithmic, square root, etc.), but we won’t be talking about those here. domain is short for an “input domain”, i.e., the range of possible input values. It takes an array of the smallest input value possible and the maximum input value. range on its own is the range of possible output values. So in domain, we’re setting the range of possible data values from our random data, and in range we’re telling D3 the range of our chart. d3.max is a D3 method for determining the maximum value of a dataset. It can take a function which D3 will use to give the max values of the X and Y coordinates.

We use the scales to render the data circles and our axes.

Let’s create the DataCircles component under unfinished/src/components/data-circles.jsx

// unfinished/src/components/data-circles.jsx
import React from 'react';

const renderCircles = (props) => {
  return (coords, index) => {
    const circleProps = {
      cx: props.xScale(coords[0]),
      cy: props.yScale(coords[1]),
      r: 2,
      key: index
    };
    return <circle {...circleProps} />;
  };
};

export default (props) => {
  return <g>{ props.data.map(renderCircles(props)) }</g>
}

In this component, we’re rendering a g element, the SVG equivalent to a div. Since we want to render a point for every set of X-Y coordinates, were must render multiple sibling elements which we wrap together in a g element for React to work. Inside of g, we’re mapping over the data and rendering a circle for each one using renderCircles. renderCircles creates an SVG circle element with a number of properties. Here’s where we’re setting the x and y coordinates (cx and cy respectively) with the D3 scales passed in from the scatter plot component. r is the radius of our circle, and key is something React requires us to do. Since we’re rendering identical sibling components, React’s diffing algorithm needs a way to keep track of them as it updates the DOM over and over. You can use any key you like, as long as it’s unique to the list. Here we’re just going to use the index of each element.

Now, when we look at our browser, we see this:

We can see our random data and randomize that data via user input. Awesome! But we’re missing a way to read this data. What we need are axes. Let’s create them now.

Let’s open up ScatterPlot.jsx and add an XYAxis component

// unfinished/src/components/scatter-plot.jsx

// ...

import XYAxis       from './x-y-axis';

// ...

export default (props) => {
  const scales = { xScale: xScale(props), yScale: yScale(props) };
  return <svg width={props.width} height={props.height}>
    <DataCircles {...props} {...scales} />
    <XYAxis {...props} {...scales} />
  </svg>
}

Now, let’s create the XYAxis component;

// unfinished/src/components/x-y-axis.jsx
import React  from 'react';
import Axis   from './axis';

export default (props) => {
  const xSettings = {
    translate: `translate(0, ${props.height - props.padding})`,
    scale: props.xScale,
    orient: 'bottom'
  };
  const ySettings = {
    translate: `translate(${props.padding}, 0)`,
    scale: props.yScale,
    orient: 'left'
  };
  return <g className="xy-axis">
    <Axis {...xSettings}/>
    <Axis {...ySettings}/>
  </g>
}

For simplicity’s sake, we’re creating two objects which will hold the props for each of our X-Y axes. Let’s create an axis component to explain what these props do. Go ahead and create axis.jsx

// unfinished/src/components/x-y-axis.jsx
import React from 'react';
import d3    from 'd3';

export default class Axis extends React.Component {
  componentDidMount() {
    this.renderAxis();
  }

  componentDidUpdate() {
    this.renderAxis();
  }

  renderAxis() {
    var node  = this.refs.axis;
    var axis = d3.svg.axis().orient(this.props.orient).ticks(5).scale(this.props.scale);
    d3.select(node).call(axis);
  }

  render() {
    return <g className="axis" ref="axis" transform={this.props.translate}></g>
  }
}

Our strategy up to this point has been to let React exclusively handle the DOM. This is a good general rule, but we should leave room for nuance. In this case, the math and work necessary in order to render an axis is quite complicated and D3 has abstracted that pretty nicely. We’re going to let D3 have access to the DOM in this case. And since we’re only going to render a ma

The mention of Dissociative Identity Disorder (DIO), more popularly known as multiple personality disorder, is likely to evoke memories of chilling sequences featuring James McAvoy in Split (2016). Or closer home, Vidya Balan in her blood-thirsty alter ego of Manjulika in Bhool Bhulaiyaa (2007). Theatre director Suketu Shah's response was no different when writer-actor Abhishek Pattnaik suggested it as the crux of their new play. So, before embarking on their production, Kaise Karenge, the duo decided to further educate themselves about the mental health condition through online research and speaking to psychologists, and came away surprised.

"Dissociative identity disorder [DIO] is often bracketed with violent personalities who do grotesque things, thanks to their on-screen portrayal. But there is really nothing to be scared of. In fact, it could even be a case of multiple specialties — more like a superpower — which comes across in the play," says Shah, who started Out of the Box Production with Pattnaik over seven years ago, making it one of the youngest professional theatre companies in the country.

Keeping up with the young vibe, the cast of the play, which revolves around the story of two brothers, includes Pattnaik and Darsheel Safary in the lead roles. Safary, known for his moving portrayal of a dyslexic child in Taare Zameen Par, plays the younger brother. A smart 21-year-old who already has four patents to his name and is about to leave for the US for his masters at the Massachusetts Institute of Technology, his world changes when he realises his elder sibling suffers from DIO. He decides to stay on, and figure out their lives together.

"I am not from a science background, so I had to take a mini crash course in it from friends pursuing their studies in the stream," admits Safary, who completed his graduation in mass media, and is considering a masters in filmmaking. Having made his foray in theatre with the English comedy Can I Help You? this is his third play.

When asked about the experience of acting on the stage vis-à-vis for the camera, he shares, "In theatre, you get to see the audience reaction live, which helps forge a connect with them. It also limits the room for error. So, with all your senses switched on, it sharpens you as an actor. This is a skill I hope to employ before the camera, too."

About playing multiple characters rolled into one, Pattnaik says that it took three months of rehearsal to get a grip over them. "I speak in Hindi; Hindi with a touch of Haryanvi; and like a pakka Mumbaikar in the roles I play. That required me to shed all inhibitions, and practise switching seamlessly from one role to another using body language and intonation," he says.

Having started out as management students who plunged into theatre full time, Pattnaik and Shah also want to use their productions to encourage young people to consider making a living in the medium. "Theatre is a challenging medium to work and survive in. Finding the right people to work with is another challenge. We learnt everything on the job," shares Shah. Pattnaik is quick to add, "But we have made it for seven-plus years. And that's the message we want to send out."

ON March 17, 6.30 pm
AT Balgandharva Rang Mandir, off Linking Road, junction of 24th and 32nd Road, next to Patwardhan Park, Bandra West
LOG ON TO bookmyshow.com
CALL 9920536475
ENTRY Rs 400 onwards

Catch up on all the latest Crime, National, International and Hatke news here. Also download the new mid-day Android and iOS apps to get latest updates

After Race 3 (2018), Jacqueline Fernandez had been missing from the scene, barring sporadic appearances in music videos with Badshah and Bigg Boss contestant Asim Riaz. So where has she been all this while? "For now, I am at a farm far away," she laughs, alluding to spending the lockdown at Salman Khan's Panvel farmhouse. "On a serious note, I went through a period where I needed to reinvent myself."

A still from Mrs Serial Killer

The actor considers Mrs Serial Killer, the crime thriller that dropped on Netflix yesterday, her first step in "rebooting myself." "I have always done mainstream films, and was tired of playing chirpy and superficial characters. I was keen to attempt something dark and complex. So when Shirish [Kunder, director] said that Manoj [Bajpayee] would be my co-star in Mrs Serial Killer, I jumped at the idea." Fernandez admits she was a bundle of nerves on the first day of shoot. "I was excited as well as petrified about working with Manoj. Going by his films, I felt he would be a strict actor. But we had a great time on the set. I had to unlearn several things while working with him."

Catch up on all the latest entertainment news and gossip here. Also, download the new mid-day Android and iOS apps.

Mid-Day is now on Telegram. Click here to join our channel (@middayinfomedialtd) and stay updated with the latest news

As an actor taking his initial steps into Bollywood, Avinash Tiwary knows that his next offering must be significantly noteworthy if he hopes to live up to the acclaim he received for his last film, Laila Majnu. Evidently then, he isn't willing to forgo the toil he put into understanding and acquiring the mindset of Dawood since early November when work on Farhan Akhtar and Ritesh Sidhwani's Dongri to Dubai first kicked off.

After the shooting was stalled in March when the lockdown was announced, Tiwary says being attuned to the character for the forthcoming leg, is becoming increasingly arduous for him. "I hope we start [shooting] soon so that I can finish it. I don't want to sit with this part for too long. As much as it is liberating to be on the OTT platform, it is suffocating to be in this mould and state of mind. It eventually gets to you because you can't live in that space forever."

It was across several sets in Mumbai that filming for the screen adaptation of Hussain Zaidi's book began, only to come to a halt on March 17. "A lot of portions are still to be shot. Now, we have no idea when we will roll again."

Having an artiste as fine as Kay Kay Menon to share screen space with implies Tiwary has abundant opportunity to grow while working on the offering. "When I started out as an actor in theatre, I would idolise him. I try and learn from everything he does on sets."

Catch up on all the latest entertainment news and gossip here. Also, download the new mid-day Android and iOS apps.

Mid-Day is now on Telegram. Click here to join our channel (@middayinfomedialtd) and stay updated with the latest news

There may not be a single soul who didn't like Irrfan Khan for some quality or the other. Be it his acting prowess, his expressive eyes, the magic in his voice, or for simply the kind of person he was, Irrfan was loved and admired by people across the world. 

When he left us on April 29, 2020, it felt like one of the darkest days Hindi cinema had seen. Messages of condolence and sorrow came in from the most unexpected corners of the world, further proving that Irrfan Khan was indeed a global icon.

Deepika Padukone and Irrfan shared screen space in the much-loved film Piku, which starred Amitabh Bachchan as well. The actress recently shared a video that shows her playing tennis with Irrfan, possibly on the sets of Piku. She remembered Irrfan with a broken heart emoji and wrote, "Please come back!"

 

 

 

View this post on Instagram

please come back!💔 #irrfankhan

A post shared by Deepika Padukone (@deepikapadukone) onMay 8, 2020 at 8:27pm PDT

Dippy and Irrfan shared a close camaraderie, which was apparent in the effortless way they shared the screen in Piku, which released on May 8, 2015. And on the fifth anniversary of their film, Deepika shared a quaint photo of herself and Irrfan in one frame laughing their hearts out.

 

 

 

View this post on Instagram

लम्हे गुज़र गये चेहरे बदल गये हम थे अंजानी राहो में पल में रुला दिया पल में हसा के फिर रह गये हम जी राहो में थोड़ा सा पानी है रंग है थोड़ी सी छावो है चुभती है आँखो में धूप ये खुली दिशाओ में और दर्द भी मीठा लगे सब फ़ासले ये कम हुए ख्वाबो से रस्ते सजाने तो दो यादो को दिल में बसाने तो दो लम्हे गुज़र गये चेहरे बदल गये हम थे अंजानी राहो में थोड़ी सी बेरूख़ी जाने दो थोड़ी सी ज़िंदगी लाखो स्वालो में ढूंधू क्या थक गयी ये ज़मीन है जो मिल गया ये आस्मा तो आस्मा से मांगू क्या ख्वाबो से रस्ते सजाने तो दो यादो को दिल में बसाने तो दो -Piku Rest in Peace my Dear Friend...💔 #rana #piku #bhaskor @shoojitsircar @juhic3 #5yearsofpiku

A post shared by Deepika Padukone (@deepikapadukone) onMay 8, 2020 at 1:45am PDT

Irrfan Khan will be missed for years to come, and will surely be never forgotten.

Catch up on all the latest entertainment news and gossip here. Also, download the new mid-day Android and iOS apps.

Mid-Day is now on Telegram. Click here to join our channel (@middayinfomedialtd) and stay updated with the latest news

Prince Narula and Yuvika Chaudhary are setting couple goals, and no one can deny that! The duo is simply smitten by each other, and can't get enough of it. As the country is under lockdown, many celebrities have been sharing encouraging videos of them spending time at home and finding multiple ways to keep themselves occupied, away from boredom.

Prince Narula too shared a video of him being a fun husband during the time of lockdown. But his prank didn't turn out as he planned! The Roadies judge was trying hard to make his wife laugh with a lighthearted game. As the video proceeds, it seems like Yuvika didn't like the prank, at all! Take a look.

In fact, when the Ex-Bigg Boss contestant shared the video, he wrote, "Prank video having fun with my wife @yuvikachaudhary. Video k baad mera kya haal hua dakheye is video main [sic]"

 

 

 

View this post on Instagram

A post shared by Prince Yuvika Narula (@princenarula) onApr 15, 2020 at 5:29am PDT

OMG! Nobody saw this coming, did you? Well, Prince Narula, don't trouble your wife, especially during the lockdown time.

Catch up on all the latest entertainment news and gossip here. Also, download the new mid-day Android and iOS apps.

Mid-Day is now on Telegram. Click here to join our channel (@middayinfomedialtd) and stay updated with the latest news

Novak Djokovic has apparently broke confinement rules in Spain by going back to a tennis court. Djokovic posted a video on Instagram showing him exchanging shots with another man at a tennis club in the coastal city of Marbella, where the Serb has reportedly stayed. Djokovic filmed the video while hitting shots and wrote he was "so happy to play on clay...well, just for a bit with my phone in the hands."

Spain on Monday loosened some of the lockdown measures that had been in place since mid-March because of the COVID-19 pandemic, allowing professional athletes to return to practice. But sports facilities are supposed to remain closed at least until next week in most parts of the country, with the exception of training centres for teams in professional leagues in sports such as soccer.

The Spanish tennis federation said in a statement on Monday that professional players in Spain were allowed to exercise by themselves or with a coach, but not yet on a tennis court. It said it would work on a set of guidelines to inform players and clubs about what they would be permitted to do beginning next week.
The federation's statement did not appear to be related to Djokovic's appearance on the court in Marbella.

Requests for comment made to the federation and to Djokovic's staff late on Monday were not immediately answered. It was not clear if Djokovic, the reigning Australian Open would be subjected to fines or sanctions if it was confirmed he broke the lockdown rules.

The No. 1-ranked Djokovic recently said he was against taking an anti-Coronavirus vaccination if it became mandatory to travel once the pandemic subsides, though he later said he was open to changing his mind.

Catch up on all the latest sports news and updates here. Also download the new mid-day Android and iOS apps to get latest updates.

Mid-Day is now on Telegram. Click here to join our channel (@middayinfomedialtd) and stay updated with the latest news

This story has been sourced from a third party syndicated feed, agencies. Mid-day accepts no responsibility or liability for its dependability, trustworthiness, reliability and data of the text. Mid-day management/mid-day.com reserves the sole right to alter, delete or remove (without notice) the content in its absolute discretion for any reason whatsoever

India's top-order batsman Cheteshwar Pujara misses playing badminton on the outdoor courts. Sporting action across the world is on pause due to the coronavirus pandemic and in India a nationwide lockdown in place till May 3 has imposed restrictions on movement of people.

Pujara, used to enjoy badminton outdoors apart from cricket. Now he plays with his wife or with his Saurashtra team-mate Jaydev Unadkat. "Usually when I am at home in Rajkot, we go and play badminton on weekends on proper courts. That is something I am missing," ESPN Cricinfo quoted Pujara as saying.

"With my wife - she wants to learn. At times if Jaydev Unadkat is in Rajkot, he is a decent badminton player, so I play with him," he added. Pujara also revealed that he is very competitive when it comes to playing badminton and he cannot let anybody win.

"No, no. I can't allow my wife to win. I can't allow anyone to win against me at badminton. That is not possible. I've been telling her that she has to get better at it and win that way. I don't want to lose to make her happy that she has beaten me. As a sportsperson your mentality is to make sure that the other person becomes stronger than you," Pujara said.

Pujara was supposed to be in the UK, playing for Gloucestershire, at this time of year, but all plans have been tossed away due to the coronavirus pandemic.

He had signed a deal in February to represent the county for the first six matches of the championship. He was set to become Gloucestershire's first Indian player after Javagal Srinath in 1995.

But with the first seven rounds of the Championship postponed due to the coronavirus pandemic, and international travel severely limited, he will be unable to fulfil his deal. The batsman was last seen in action during India's two-match Test series against New Zealand.